8.5 Einige Objekte in Word 

Auch hier - ähnlich wie bei Excel - leistet der Makrorekorder nützliche Dienste. Doch Achtung: Um die Befehle, die aufgezeichnet werden, zu interpretieren und weiterzuverarbeiten, sollten Sie gute Word-Kenntnisse haben. Das beginnt schon bei der ersten Frage: Wie schreibe ich etwas in Word hinein? Die Antwort mag trivial erscheinen, aber in Bezug auf unsere Rechnung ist sie es nicht. Ich denke an drei Varianten:

Man könnte per Programmierung die Befehle aufzeichnen lassen, mit denen ein Text erstellt und formatiert wird. Sehr effektiv ist das allerdings nicht.

Man könnte eine Dokumentvorlage verwenden (Datei . Neu), in der sich an bestimmten Stellen Textmarken (Einfügen . Textmarke) befinden, die angesprungen werden und in die Text eingetragen wird.

Und schließlich könnte man mittels einer geschützten Dokumentvorlage (Extras . Dokument schützen) Formularfelder mit bestimmten Texten füllen lassen.

Um alle drei Varianten ausführlich zu beschreiben, könnte man dicke Bücher füllen. Ich begnüge mich hier mit einigen Besonderheiten und zeige das Vorgehen exemplarisch.

8.5.1 Der Makrorekorder 

Zeichnet man mit dem Makrorekorder in Word die Befehle auf, die ein neues, leeres Dokument erzeugen und dort einen Text hineinschreiben, so erhält man folgende Befehle:

Sub Makro1()
'
' Makro1 Makro
' Makro aufgezeichnet am 30.07.02 von Rene Martin
'
   Documents.Add DocumentType:=wdNewBlankDocument
   Selection.TypeText Text:="Ich weiß nicht, was soll das bedeuten,"
   Selection.TypeParagraph
   Selection.TypeText Text:="dass ich so traurig bin."
   Selection.TypeParagraph
   Selection.TypeText Text:="Ein Märchen aus uralten Zeiten"
   Selection.TypeParagraph
   Selection.TypeText Text:="Das will mir nicht aus dem Sinn."
End Sub

8.5.2 Application 

Einige Erläuterungen hierzu: Oberstes Objekt in Word ist - genau wie in Excel - auch Application. Dieses besitzt, ähnlich wie Excel, ein ActiveDocument und die Sammlung der offenen Dateien Documents.

8.5.3 Methoden und Eigenschaften von Document und Documents 

Ein neues Dokument wird mit der Methode Add erzeugt. Dies entspricht in Word dem Befehl Datei . Neu:

Application.Documents.Add([Template], [NewTemplate])

oder

Documents.Add([Template], [NewTemplate])

Dabei entspricht Template dem Namen der Vorlage und NewTemplate der Frage, ob das Dokument als Dokumentvorlage (zur Weiterbearbeitung) geöffnet werden soll. Zum Beispiel:

Documents.Add Template:="C:\OFFICE\VORLAGEN\Examen.dot", _
   NewTemplate:=False

Wird ein neues, leeres Dokument geöffnet, das auf der Vorlage »Normal.dot« basiert, dann genügt der Befehl

Documents.Add 

Ein vorhandenes Dokument wird mit der Methode Open geöffnet, wobei der Dateiname als String anzugeben ist. Daneben stehen eine ganze Reihe weiterer Optionen zur Verfügung, die hier nicht erläutert werden sollen.

Dies könnte folgendermaßen aussehen:

Documents.Open FileName:="k1.doc", _
   ConfirmConversions:=False, ReadOnly:= False, _
   AddToRecentFiles:=False, PasswordDocument:="", _
   PasswordTemplate:= "", Revert:=False, _
   WritePasswordDocument:="", WritePasswordTemplate:="", _
   Format:=wdOpenFormatAuto

oder auch nur so:

Documents.Open _
   FileName:="C:\Eigene Dateien\Heine.doc"

oder analog:

Documents.Open "C:\Eigene Dateien\Heine.doc"

Geschlossen wird das aktuelle Dokument mit:

ActiveDocument.Close

Diese Methode hat drei Parameter:

ActiveDocument.Close SaveChanges:=wdPromptToSaveChanges

Für das Speichern stehen die Methoden Save und SaveAs mit eine Reihe von Parametern zur Verfügung:

Sollten mehrere Dateien geöffnet sein, so kann man in Word über das Menü Fenster oder über die Taskleiste dorthin springen. Im Menü Fenster haben alle Dateien eine Nummer. Über diese Nummer oder über ihren Namen kann man sie anspringen. In VBA steht dazu der Befehl

Application.Documents(1).Activate

oder

Application.Documents("Heine.doc").Activate

Gedruckt wird mit der Methode PrintOut. Auch sie besitzt eine Reihe von Parametern. Das Objekt Application ist auch hier (in VBA) überflüssig.

Word wird mit der folgenden Methode beendet:

Application.Quit

Dieser Befehl hat die gleichen drei Parameter wie Close: SaveChanges, OriginalFormat und RouteDocument.

8.5.4 Text in Word schreiben 

Selection ist eine Eigenschaft von Application, das heißt, der Text wird in das gerade aktive Dokument von Word geschrieben. Zwar ist es auch möglich, in ein anderes offenes Dokument Text zu schreiben, allerdings kann dann nicht eine bestimmte Stelle angesprungen werden. Der hierzu nötige Befehl lautet:

Documents(3).Range.Text = _
"Die Luft ist kühl und es dunkelt" & vbCr & _
"Und ruhig fließt der Rhein;"

Allerdings bezieht sich das Objekt Range auf das gesamte Dokument, sodass bereits vorhandener Text gelöscht würde. Mit dem Objekt Selection kann dagegen eine bestimmte Textstelle angesprungen werden. Einige wichtige Methoden werden in der folgenden Tabelle aufgelistet:

Umgekehrt kann nicht nur eine bestimmte Stelle innerhalb eines Dokuments angesprungen, sondern auch ein Teil eines markierten Texts ausgelesen werden. Der Befehl

Selection.Text 

liest den ganzen Text aus, der weiterverarbeitet werden kann.

8.5.5 Tabellen in Word 

Neben der Texteingabe, dem Markieren und Abfangen der Markierung, dem Verändern und der Positionsbestimmung gibt es ein weiteres Element, das häufig im Dokument auftaucht und das genauere Betrachtung erfordert: die Tabellen. Eine Tabelle wird mit folgender Anweisung erzeugt:

ActiveDocument.Tables.Add (Range, NumRows, NumColumns)

Zum Beispiel soll eine neue Tabelle fünf Spalten und drei Zeilen haben:

ActiveDocument.Tables.Add Range:=Selection.Range, _
   NumRows:=3, NumColumns:= 5

Ob sich der Cursor in der Tabelle befindet, kann mit der Konstante wdWithInTable erfragt werden:

If Selection.Information(wdWithInTable) = True Then 
   MsgBox "Ich bin in der Tabelle"
Else
   MsgBox "Ich bin nicht in der Tabelle"
End If

Jede Zeile und jede Spalte hat eine Nummer. Angenommen, Sie benötigen viele Tabellen, die als gemeinsames Merkmal eine graue Schattierung von 25  % haben:

Dann können diese Tabellen so erzeugt werden:

Sub TabelleGrauerKopf()
ActiveDocument.Tables.Add Range:=Selection.Range, _
   NumRows:=3, NumColumns:=2
         ' Wenn Sie das Objekt Range vergessen, 
         ' so erhalten Sie eine Fehlermeldung
With ActiveDocument.Tables(1).Rows(1)
   .Shading.Texture = wdTexture25Percent
   With .Borders
      .InsideLineStyle = wdLineStyleSingle
      .OutsideLineStyle = wdLineStyleSingle
   End With
End With
End Sub

Im aktiven Dokument wird der ersten Tabelle und dort der ersten Zeile der Schattierung die Eigenschaft »Texture« »25  % grau« zugewiesen. Danach erhalten im selben Dokument in derselben Tabelle in derselben Zeile die Ränder die Eigenschaft InsideLineStyle = einfache Linie (wdLineStyleSingle), ebenso OutsideLineStyle.

Achtung: Wenn Sie das aufzeichnen und testen, dann klappt es beim zweiten Mal nicht mehr, weil ActiveDocument.Tables(1) nur die erste Tabelle bezeichnet. Nur diese wird formatiert. Deshalb muss mit einer Objektvariablen gearbeitet werden. Beispielsweise so:

Sub TabelleGrauerKopf()
Dim wdTabelle As Table
Set wdTabelle = ActiveDocument.Tables.Add( _
   Range:=Selection.Range, _
   NumRows:=3, NumColumns:=2)
wdTabelle.Rows(1).Shading.Texture _
   = wdTexture25Percent

   With wdTabelle.Borders
      .InsideLineStyle = wdLineStyleSingle
      .OutsideLineStyle = wdLineStyleSingle
   End With

End Sub

8.5.6 Eine Klasse für den Word-Zugriff 

Mit diesem Wissen können nun in VB.NET Objekte mit Methoden und Eigenschaften erzeugt werden, die auf Word zugreifen. Zuerst muss ein Verweis auf Word gesetzt werden (Projekt · Verweise · COM). Danach wird eine neue Klasse mit dem Namen clsWord erstellt. Sie besteht weitgehend aus Methoden, beispielsweise den folgenden:

Imports System.IO
Public Class clsWord

   Dim m_wdApp As Word.Application
   Dim m_wdDatei As Word.Document
   Dim m_wdTabelle As Word.Table

   Sub Dateizugriff()
      Try
         m_wdApp = New Word.Application()
         m_wdApp.Visible = True
         m_wdDatei = m_wdApp.Documents.Add
      Catch ex As IOException
         MessageBox.Show(ex.Message)
      Catch ex As FileNotFoundException
         MessageBox.Show("so nicht!")
         MessageBox.Show(ex.Message)
         Exit Sub
      End Try
   End Sub

   Sub SchreibeText(ByVal Text As String)
      m_wdApp.Selection.TypeText(Text)
   End Sub

   Sub NeueZeile()
      m_wdApp.Selection.TypeParagraph()
   End Sub

   Sub NeueZeile(ByVal ZeilenZahl as Integer)
      Dim i As Integer
      For i = 1 To Zeilenzahl
         m_wdApp.Selection.TypeParagraph()
      Next
   End Sub

   Sub MacheTabelle(ByVal Zeilen As Integer, _
   ByVal Spalten As Integer)
      m_wdTabelle = _
      m_wdDatei.Tables.Add(m_wdApp.Selection.Range, _
      Zeilen, Spalten)
   End Sub

   Sub TextInTabelle(ByVal Text As String, _
      ByVal Zeile As Integer, _
      ByVal Spalte As Integer)
   m_wdTabelle.Rows().Item(Zeile).Cells().Item(Spalte). _
   Range.Text = Text
   End Sub

   Sub GeheAnsEnde()
      m_wdApp.Selection.EndKey(Word.WdUnits.wdStory)
   End Sub
End Class

Zu den Methoden Dateizugriff, SchreibeText, NeueZeile, MacheTabelle, TextInTabelle und GeheAnsEnde gibt es nicht viel zu sagen. Verwendet werden die globalen Variablen m_wdApp, m_wdDatei und m_wdTabelle. Hinter ihnen verbergen sich Word, die aktuelle Datei und eine Tabelle. Einige Methoden erhalten Parameter (TextInTabelle), andere nicht (Dateizugriff). Erwähnenswert bleibt noch die überladene Funktion NeueZeile, die entweder eine neue Zeile oder mehrere erzeugt - je nachdem, ob eine Zahl eingegeben wird oder nicht.

8.5.7 clsWord wird verwendet - Variante 1: Text hineinschreiben 

Hinter eine Befehlsschaltfläche wird nun folgender Code gelegt, mit dem das neue Objekt verwendet wird.

Private Sub butRechnung1_Click(ByVal sender As _
System.Object, ByVal e As System.EventArgs) _
Handles butRechnung1.Click
   Dim WD As clsWord
   Dim decB As Decimal
   WD = New clsWord()

   If Me.lstListe.SelectedIndex = -1 Then
      MessageBox.Show("Bitte einen Namen auswählen!")
   Else
      decB = decBetrag(Me.lstListe.SelectedIndex)
      With WD
         .Dateizugriff()

         .SchreibeText("München, den " & _
         System.DateTime.Today.ToString("dd. MMMM yyyy"))
         .NeueZeile()
         .SchreibeText("An: " & Me.lstListe.SelectedItem)
         .NeueZeile(3)
         .SchreibeText("Bitte zahlen Sie den unten " & _
         "stehenden Betrag auf mein Konto. ")
         .SchreibeText("Aber dalli, sonst setzt es was!")
         .NeueZeile(2)

         .MacheTabelle(4, 4)
         .TextInTabelle("Betrag", 1, 4)
         .TextInTabelle(System.DateTime.Today. _
         ToShortDateString, 2, 1)
         .TextInTabelle("E", 2, 3)
         .TextInTabelle(decB.ToString("F2"), 2, 4)
         .TextInTabelle("MWSt", 3, 1)
         .TextInTabelle("E", 3, 3)
         .TextInTabelle((decB * 0.16). _
         ToString("F2"), 3, 4)
         .TextInTabelle("Gesamt", 4, 1)
         .TextInTabelle("E", 4, 3)
         .TextInTabelle((decB * 1.16).ToString("F2"), 4, 4)

         .GeheAnsEnde()
         .NeueZeile(2)
         .SchreibeText("Bitte bezahlen Sie sofort.")
         .NeueZeile()
         .SchreibeText("Und nichts abziehen!")

      End With
   End If
End Sub

Abbildung 8.10   Nachdem die Namen ausgelesen wurden, wird einer ausgewählt.

Abbildung 8.11   Für ihn wird eine Rechnung erzeugt.

Zugegebenermaßen ist weder der Text sehr originell noch das Dokument ansprechend gestaltet. Man könnte beispielsweise das Datum und das E-Zeichen rechtsbündig, den Namen fett und so weiter gestalten. Dies sei jedoch dem Leser überlassen. Die entsprechenden Word-Befehle - falls sie nicht bekannt sind - erhalten Sie über den Makrorekorder.

8.5.8 Variante 2: Text in eine Dokumentvorlage an Textmarken schreiben 

Allerdings ist die obige Variante nicht sehr sinnvoll. Stellen Sie sich einen großen Konzern vor, der sein Corporate Design wechselt. Dann müssten viele Zeilen Code geändert oder neu geschrieben werden. Schneller funktioniert es, wenn eine Vorlage für die Rechnungen erstellt wird. Sie kann schnell verändert und der Code muss nicht angepasst werden.

Abbildung 8.12   Das fertige Formular

Im ersten Schritt wird das Formular erstellt und gestaltet. An den Stellen, an denen per Programmierung Text eingefügt wird, wird eine Textmarke gesetzt. Über das Menü Extras . Optionen im Registerblatt Ansicht können die Textmarken sichtbar gemacht werden. Wird der Cursor auf eine Textmarke gesetzt, dann zeigt Einfügen . Textmarken den Namen an. Die gesamte Liste finden Sie auch in Bearbeiten . Gehe zu Textmarken. Von dort aus können die Textmarken ebenfalls angesprungen werden.

Die Dokumentvorlage des Beispiels trägt den Namen »Rechnungsformular.dot«. Für uns interessant sind die Marken »Adresse«, »Rechnungsdatum«, »Datum1«, »Preis1«, »Preis_gesamt_a« »MWSt« und »Preis_gesamt_b«. Der Befehl, den der Makrorekorder liefert, mit dem eine Marke angesprungen werden kann, lautet:

Selection.GoTo What:=wdGoToBookmark, Name:="BobBeamon"
Selection.Find.ClearFormatting
With Selection.Find
   .Text = ""
   .Replacement.Text = ""
   .Forward = True
   .Wrap = wdFindContinue
   .Format = False
   .MatchCase = False
   .MatchWholeWord = False
   .MatchWildcards = False
   .MatchSoundsLike = False
   .MatchAllWordForms = False
End With

Word zeichnet leider alle Befehle auf, die der GeheZu-Dialog liefert. Die Zeile

Selection.GoTo What:=wdGoToBookmark, Name:="BobBeamon"

genügt. Es geht jedoch noch eleganter. Die Bookmarks sind ein Objekt von Activedocument. Und damit können sie direkt per Objektzugriff »gefüllt« werden.

Dazu benötigen wir zwei weitere Methoden in der Klasse. Die erste ist dafür verantwortlich, die Dokumentvorlage herzuholen. Da bereits eine Methode zum Öffnen eines leeren Dokuments existiert, kann diese verwendet und überladen werden:

   Sub Dateizugriff(Vorlagenname As String)
      Try
         m_wdApp = New Word.Application()
         m_wdApp.Visible = True
         If VorlagenName.EndsWith(".dot") = False Then
            VorlagenName &=".dot"
         End If
         m_wdDatei = m_wdApp.Documents.Add(Vorlagenname)
      Catch ex As IOException
         MessageBox.Show(ex.Message)
      Catch ex As FileNotFoundException
         MessageBox.Show("so nicht!")
         MessageBox.Show(ex.Message)
         Exit Sub
      End Try
   End Sub

Die zweite Methode fügt an den entsprechenden Textmarken die korrespondierenden Texte ein:

Sub TextmarkeFüllen(ByVal Marke As String, _
ByVal Text As String)
   If m_wdDatei.Bookmarks.Exists(Marke) = True Then
      m_wdDatei.Bookmarks().Item(Marke).Range.Text = Text
   End If
End Sub

Nun wird hinter einer zweiten Schaltfläche der Code implementiert, mit dem die beiden neuen Methoden verwendet werden.

Abbildung 8.13   Der zweite Button

Private Sub butRechnung2_Click(ByVal sender As _
System.Object, ByVal e As System.EventArgs) Handles _
butRechnung2.Click
   Dim WD As clsWord
   Dim decB As Decimal
   WD = New clsWord()

   If Me.lstListe.SelectedIndex = -1 Then
      MessageBox.Show("Bitte einen Namen auswählen!")
   Else
      decB = decBetrag(Me.lstListe.SelectedIndex)
      With WD
         .Dateizugriff("D:\Data\Rechnungsformular.dot")
         .TextmarkeFüllen("Adresse", _
         Me.lstListe.SelectedItem)
         .TextmarkeFüllen("Rechnungsdatum", _
         System.DateTime.Today.ToShortDateString)
         .TextmarkeFüllen("Datum1", _
         System.DateTime.Today.ToShortDateString)
         .TextmarkeFüllen("Preis1", _
         decB.ToString("C"))
         .TextmarkeFüllen("Preis_gesamt_a", _
         decB.ToString("C"))
         .TextmarkeFüllen("Preis_gesamt_b", _
         (decB * 1.16).ToString("C"))
         .TextmarkeFüllen("MWSt", _
         (decB * 0.16).ToString("C"))
      End With
   End If
End Sub

Der Code wird übersichtlicher als in der ersten Variante. Um die Gestaltung des Dokuments braucht man sich nun bei der Programmierung keine Gedanken mehr zu machen.

Abbildung 8.14   Die fertige Rechnung

8.5.9 Variante 3: Eine geschützte Dokumentvorlage mit Formularfeldern 

Es lohnt sich, auch die dritte Variante zu demonstrieren. Leider kann man in geschützten Formularen nicht den Makrorekorder einsetzen, um an die Befehle zu kommen. Dazu benötigt man ein paar Informationen.

Um in einer Word-Datei Formularfelder einzufügen, muss die Symbolleiste Formular (Ansicht . Symbolleisten oder Extras . Anpassen) geöffnet werden. Dort finden sich drei verschiedene Formularfelder: Textfelder, Kontrollkästchen und Dropdown-Felder. Sie werden durch Anklicken in ein Word-Dokument eingefügt.

Werden Formularfelder in der Form {FORMTEXT} angezeigt, dann kann diese Ansicht über Extras . Optionen . Ansicht . Feldfunktionen oder mit der Tastenkombination (Alt) + (F9) ausgeschaltet werden. Damit die Formularfelder ordentlich nebeneinander und untereinander stehen, sollte mit einer Tabelle gearbeitet werden.

Damit ein Dokument ausgefüllt werden kann, muss es geschützt werden. Dies kann über das Formular-schützen-Symbol der Formular-Symbolleiste geschehen. Damit kann der Benutzer nur noch auf die einzelnen Formularfelder zugreifen.

Zugelassen sind in den unformatierten Textformularfeldern alle Arten der Eingabe: Text, Zahlen, ¶-Zeichen; die Anzahl der eingegebenen Zeichen ist unbegrenzt. Da auf dem Dokument ein Schutz liegt, kann der Benutzer keine Textbausteine verwenden. Ebenso ist die Silbentrennung inaktiv. Die Autokorrektur funktioniert ebenso wenig wie das Formatieren. Um diese Probleme zu umgehen, können freie Bereiche (Abschnitte) definiert werden.

Dazu werden in einem ungeschützten Dokument Formularfelder eingefügt. Nach (oder vor) diesem Bereich kann über den Menüpunkt Einfügen . Manueller Wechsel . Abschnittswechsel Fortlaufend ein neuer Abschnitt definiert werden. Damit nun in einem Dokument nur ein bestimmter Abschnitt geschützt wird, muss der Menüpunkt Extras . Dokument Schützen . Formulare ausgewählt werden. Hinter der Schaltfläche Abschnitte verbirgt sich die Liste der Abschnitte des Dokuments. Sie können einzeln geschützt werden oder offen bleiben. Nun kann der Schutz auf das Dokument gelegt werden.

Normalerweise wird ein Word-Formular so ausgedruckt, wie es auf dem Bildschirm sichtbar ist. Angenommen, es sollen nur die Daten gedruckt werden, da beispielsweise schon ein Papierformular vorliegt, so kann über das Menü Extras . Optionen . Drucken festgelegt werden, dass In Formularen nur Daten drucken gewünscht wird. Zwar zeigt die Seitenansicht noch die übrigen Texte an, aber auf dem Papier erscheinen nur die eingegebenen Texte, die Kreuze der ausgewählten Kontrollkästchen und die gewählten Einträge der Dropdown-Felder.

Abbildung 8.15   Das geschützte Rechnungsformular mit Formularfeldern

8.5.10 Word-Formulare steuern 

Um per Programmierung auf ein Formularfeld zugreifen zu können, muss es einen Namen besitzen. Diesen finden Sie im Eigenschaftendialog. Im Folgenden wird das Textfeld »T1« genannt, das Kontrollkästchen »K1« und das Dropdown-Feld »D1«. Alle sind Objekte von Document.

Mit dem Wissen um die Befehle ist ein gutes Fundament geschaffen, wenn es darum geht, Formularfelder zu steuern. Zwei weitere Befehle scheinen dennoch wichtig:

Da Word-Formulare immer geschützt sind (oder zumindest geschützte Abschnitte besitzen), muss zuweilen per Programmierung der Schutz aufgehoben werden:

ActiveDocument.Unprotect

Liegt auf dem geschützten Dokument ein Passwort, so wird es als Parameter dahinter eingefügt, also beispielsweise so:

ActiveDocument.Unprotect "Passwort"

Soll der Schutz wieder eingeschaltet werden, dann geschieht dies mit der Methode Protect:

ActiveDocument.Protect Type, [NoReset], [Password]

beispielsweise so:

ActiveDocument.Protect Type:=wdAllowOnlyFormFields, _
   NoReset:=True, Password:=""

Der Parameter Type ist notwendig und lautet wdAllowOnlyFormFields, da es um die Freigabe der Formularfelder geht. Password ist optional, kann weggelassen werden oder durch »« explizit als »kein Passwort« gekennzeichnet werden. Wird NoReset auf False gesetzt, dann werden nach dem Einschalten des Dokumentschutzes alle Feldinhalte gelöscht und nur die Vorgabewerte angezeigt. Sollen die Inhalte jedoch erhalten bleiben, dann ist dieser Wert auf True zu setzen.

Nun wird in unserem Programm nur noch eine weitere Methode benötigt, die das Ausfüllen von Formularfeldern ermöglicht:

Sub FormularfeldFüllen(ByVal Name As String, _
ByVal Text As String)
   If m_wdDatei.Bookmarks.Exists(Name) = True Then
      m_wdDatei.FormFields().Item(Name).Result = Text
   End If
End Sub

Die für uns wichtigen Formularfelder heißen »Datum«, »Vorname«, »Betrag«, »MWSt« und »Gesamt«. Hinter einem dritten Button verbirgt sich folgender Code:

Private Sub butRechnung3_Click(ByVal sender As _
System.Object, ByVal e As System.EventArgs) Handles _
butRechnung3.Click
   Dim WD As clsWord
   Dim decB As Decimal
   WD = New clsWord()

   If Me.lstListe.SelectedIndex = -1 Then
      MessageBox.Show("Bitte einen Namen auswählen!")
   Else
      decB = decBetrag(Me.lstListe.SelectedIndex)
      With WD
         .Dateizugriff("D:\Data\Rechnung.dot")
         .FormularfeldFüllen("Vorname", _
         Me.lstListe.SelectedItem)
         .FormularfeldFüllen("Betrag", decB.ToString("C"))
         .FormularfeldFüllen("MWSt", _
         (decB * 0.16).ToString("C"))
         .FormularfeldFüllen("Gesamt", _
         (decB * 1.16).ToString("C"))
         .FormularfeldFüllen("Datum", _
         System.DateTime.Today.ToShortDateString)
      End With
   End If
End Sub

Abbildung 8.16   Der dritte Button

Abbildung 8.17   Die fertige Rechnung (Variante 3)